import { ref } from 'vue';

interface MomentumOptions {
  deceleration?: number;    // 减速度系数
  minVelocity?: number;     // 最小速度阈值
}

interface MomentumResult {
  targetPosition: number;   // 目标位置
  shouldApply: boolean;     // 是否应该应用惯性
}

/**
 * 惯性计算hooks
 */
export function useMomentumCalculation(options: MomentumOptions = {}) {
  const {
    deceleration = 0.0015,  // 调整默认减速度值
    minVelocity = 0.05
  } = options;

  // 存储上一次的位置和时间信息
  const lastInfo = ref<{
    position: number;
    time: number;
  } | null>(null);

  // 当前速度
  const velocity = ref(0);

  /**
   * 开始跟踪位置变化
   * @param position 初始位置
   */
  const startTracking = (position: number) => {
    lastInfo.value = {
      position,
      time: Date.now()
    };
    velocity.value = 0;
  };

  /**
   * 更新位置信息并计算速度
   * @param position 当前位置
   */
  const updatePosition = (position: number) => {
    const currentTime = Date.now();
    
    if (lastInfo.value) {
      const deltaTime = currentTime - lastInfo.value.time;
      if (deltaTime > 0) {
        // 计算瞬时速度
        const deltaPosition = position - lastInfo.value.position;
        const currentVelocity = deltaPosition / deltaTime;
        
        // 使用简单的移动平均平滑速度
        velocity.value = velocity.value * 0.6 + currentVelocity * 0.4;
      }
    }
    
    // 更新最后信息
    lastInfo.value = {
      position,
      time: currentTime
    };
  };

  /**
   * 计算惯性滚动的目标位置
   * @param currentPosition 当前位置
   * @param minPosition 最小边界位置
   * @param maxPosition 最大边界位置
   * @returns 惯性计算结果
   */
  const calculateMomentum = (
    currentPosition: number,
    minPosition: number,
    maxPosition: number
  ): MomentumResult => {
    // 如果速度太小，不应用惯性
    if (Math.abs(velocity.value) < minVelocity) {
      return {
        targetPosition: currentPosition,
        shouldApply: false
      };
    }

    // 使用更简单的惯性计算方式
    // 计算惯性滚动时间 (t = v/a)
    const momentumTime = Math.abs(velocity.value) / deceleration;
    
    // 计算惯性滚动距离 (s = vt - (1/2)at²)
    const distance = velocity.value * momentumTime - 
                    (velocity.value > 0 ? 1 : -1) * 0.5 * deceleration * momentumTime * momentumTime;
    
    // 计算目标位置并限制在边界内
    let targetPosition = currentPosition + distance;
    targetPosition = Math.max(minPosition, Math.min(maxPosition, targetPosition));
    
    return {
      targetPosition,
      shouldApply: true
    };
  };

  /**
   * 重置状态
   */
  const reset = () => {
    lastInfo.value = null;
    velocity.value = 0;
  };

  return {
    startTracking,
    updatePosition,
    calculateMomentum,
    reset,
    velocity: velocity
  };
}